Would it be better to make collectAssertions(...) fail the explanatory group when the assertionCreator doesn't create any assertions?

sounds like a reasonable thing. That an explanatory group can fail is rather a new thing

I realize I'm not actually sure how to modify the builder to accomplish this.

I'm looking at AssertionOptionExplanatoryExtensions.kt and I'm not sure how to get the extension method .collectAssertions to produce a failing final step.

My naive attempt:

fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAssertions(
    container: AssertionContainer<*>,
    maybeSubject: Option<T>,
    assertionCreator: Expect<T>.() -> Unit
): R {
    val collectingExpect = CollectingExpect<T>(None, container.components)
    // not using addAssertionsCreatedBy on purpose so that we don't append a failing assertion
    collectingExpect.assertionCreator()
    return withAssertions(container.collectForCompositionBasedOnSubject(maybeSubject, assertionCreator))
        .let {
            if(collectingExpect.getAssertions().isEmpty()) it.failing
            else it
        }
}

has issues because the return type is the generic type R and it doesn't recognize .failing. I'm not really understanding here how the builder pattern is implemented here with the generic AssertionsOption<G,R> type.

You need to restrict R with an upper bound of ExplanatoryGroup.FinalStep.kt in AssertionOptionExplanatoryExtensions.kt.
So like the following:

fun <T, G : ExplanatoryAssertionGroupType, R : ExplanatoryGroup.FinalStep> AssertionsOption<G, R>.collectAssertions(...

With the above type signature the compiler complained about two things:

• It expects the method to return R but the inferred type is ExplanatoryGroup.FinalStep
• Elsewhere in the code, in 4 other places, it complains about the upper bound R : ExplanatoryGroup.FinalStep, saying ExplanatoryAssertionGroupFinalStep isn't a subtype of ExplanatoryGroup.FinalStep. I think the problem is that the type options withDefaultType, withWarningType, withInformationType and withType all have a type signature AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>, at least for now. I saw your notes about replacing ExplanatoryAssertionGroupFinalStep with ExplanatoryGroup.FinalStep before version 1.0.0.

So I had to use the following to satisfy the compiler.

fun <T, G : ExplanatoryAssertionGroupType, R : ExplanatoryAssertionGroupFinalStep> AssertionsOption<G, R>.collectAssertions(
    container: AssertionContainer<*>,
    maybeSubject: Option<T>,
    assertionCreator: Expect<T>.() -> Unit
) : ExplanatoryAssertionGroupFinalStep {
  // ...
}

However this generates a warning on compilation. Am I approaching this in the right way? Do we suppress/ignore the warning or do something else?